home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_cvs.idb / usr / freeware / info / cvs.info-1.z / cvs.info-1
Encoding:
GNU Info File  |  1999-04-16  |  48.9 KB  |  1,139 lines
  1. This is Info file cvs.info, produced by Makeinfo version 1.67 from the
  2. input file ./cvs.texinfo.
  3.  
  4. START-INFO-DIR-ENTRY
  5. * CVS: (cvs).          Concurrent Versions System
  6. END-INFO-DIR-ENTRY
  7.  
  8.    Copyright (C) 1992, 1993 Signum Support AB Copyright (C) 1993, 1994
  9. Free Software Foundation, Inc.
  10.  
  11.    Permission is granted to make and distribute verbatim copies of this
  12. manual provided the copyright notice and this permission notice are
  13. preserved on all copies.
  14.  
  15.    Permission is granted to copy and distribute modified versions of
  16. this manual under the conditions for verbatim copying, provided also
  17. that the entire resulting derived work is distributed under the terms
  18. of a permission notice identical to this one.
  19.  
  20.    Permission is granted to copy and distribute translations of this
  21. manual into another language, under the above conditions for modified
  22. versions, except that this permission notice may be stated in a
  23. translation approved by the Free Software Foundation.
  24.  
  25. 
  26. File: cvs.info,  Node: Top,  Next: Overview,  Up: (dir)
  27.  
  28.  
  29.  
  30.    This info manual describes how to use and administer CVS version
  31. 1.10.
  32.  
  33. * Menu:
  34.  
  35. * Overview::                    An introduction to CVS
  36. * Repository::                  Where all your sources are stored
  37. * Starting a new project::      Starting a project with CVS
  38. * Revisions::                   Numeric and symbolic names for revisions
  39. * Branching and merging::       Diverging/rejoining branches of development
  40. * Recursive behavior::          CVS descends directories
  41. * Adding and removing::         Adding/removing/renaming files/directories
  42. * History browsing::            Viewing the history of files in various ways
  43.  
  44. CVS and the Real World.
  45. ----------------------
  46. * Binary files::                CVS can handle binary files
  47. * Multiple developers::         How CVS helps a group of developers
  48. * Revision management::         Policy questions for revision management
  49. * Keyword substitution::        CVS can include the revision inside the file
  50. * Tracking sources::            Tracking third-party sources
  51. * Builds::                      Issues related to CVS and builds
  52. * Special Files::        Devices, links and other non-regular files
  53.  
  54. References.
  55. ----------
  56. * CVS commands::                CVS commands share some things
  57. * Invoking CVS::                Quick reference to CVS commands
  58. * Administrative files::        Reference manual for the Administrative files
  59. * Environment variables::       All environment variables which affect CVS
  60. * Compatibility::               Upgrading CVS versions
  61. * Troubleshooting::             Some tips when nothing works
  62. * Credits::                     Some of the contributors to this manual
  63. * BUGS::                        Dealing with bugs in CVS or this manual
  64. * Index::                       Index
  65.  
  66. 
  67. File: cvs.info,  Node: Overview,  Next: Repository,  Prev: Top,  Up: Top
  68.  
  69. Overview
  70. ********
  71.  
  72.    This chapter is for people who have never used CVS, and perhaps have
  73. never used version control software before.
  74.  
  75.    If you are already familiar with CVS and are just trying to learn a
  76. particular feature or remember a certain command, you can probably skip
  77. everything here.
  78.  
  79. * Menu:
  80.  
  81. * What is CVS?::                What you can do with CVS
  82. * What is CVS not?::            Problems CVS doesn't try to solve
  83. * A sample session::            A tour of basic CVS usage
  84.  
  85. 
  86. File: cvs.info,  Node: What is CVS?,  Next: What is CVS not?,  Up: Overview
  87.  
  88. What is CVS?
  89. ============
  90.  
  91.    CVS is a version control system.  Using it, you can record the
  92. history of your source files.
  93.  
  94.    For example, bugs sometimes creep in when software is modified, and
  95. you might not detect the bug until a long time after you make the
  96. modification.  With CVS, you can easily retrieve old versions to see
  97. exactly which change caused the bug.  This can sometimes be a big help.
  98.  
  99.    You could of course save every version of every file you have ever
  100. created.  This would however waste an enormous amount of disk space.
  101. CVS stores all the versions of a file in a single file in a clever way
  102. that only stores the differences between versions.
  103.  
  104.    CVS also helps you if you are part of a group of people working on
  105. the same project.  It is all too easy to overwrite each others' changes
  106. unless you are extremely careful.  Some editors, like GNU Emacs, try to
  107. make sure that the same file is never modified by two people at the
  108. same time.  Unfortunately, if someone is using another editor, that
  109. safeguard will not work.  CVS solves this problem by insulating the
  110. different developers from each other.  Every developer works in his own
  111. directory, and CVS merges the work when each developer is done.
  112.  
  113.    CVS started out as a bunch of shell scripts written by Dick Grune,
  114. posted to the newsgroup `comp.sources.unix' in the volume 6 release of
  115. December, 1986.  While no actual code from these shell scripts is
  116. present in the current version of CVS much of the CVS conflict
  117. resolution algorithms come from them.
  118.  
  119.    In April, 1989, Brian Berliner designed and coded CVS.  Jeff Polk
  120. later helped Brian with the design of the CVS module and vendor branch
  121. support.
  122.  
  123.    You can get CVS in a variety of ways, including free download from
  124. the internet.  For more information on downloading CVS and other CVS
  125. topics, see:
  126.  
  127.      http://www.cyclic.com/
  128.      http://www.loria.fr/~molli/cvs-index.html
  129.  
  130.    There is a mailing list, known as `info-cvs', devoted to CVS.  To
  131. subscribe or unsubscribe write to `info-cvs-request@gnu.org'.  If you
  132. prefer a usenet group, the right group is `comp.software.config-mgmt'
  133. which is for CVS discussions (along with other configuration management
  134. systems).  In the future, it might be possible to create a
  135. `comp.software.config-mgmt.cvs', but probably only if there is
  136. sufficient CVS traffic on `comp.software.config-mgmt'.
  137.  
  138.    You can also subscribe to the bug-cvs mailing list, described in
  139. more detail in *Note BUGS::.  To subscribe send mail to
  140. bug-cvs-request@gnu.org.
  141.  
  142. 
  143. File: cvs.info,  Node: What is CVS not?,  Next: A sample session,  Prev: What is CVS?,  Up: Overview
  144.  
  145. What is CVS not?
  146. ================
  147.  
  148.    CVS can do a lot of things for you, but it does not try to be
  149. everything for everyone.
  150.  
  151. CVS is not a build system.
  152.      Though the structure of your repository and modules file interact
  153.      with your build system (e.g. `Makefile's), they are essentially
  154.      independent.
  155.  
  156.      CVS does not dictate how you build anything.  It merely stores
  157.      files for retrieval in a tree structure you devise.
  158.  
  159.      CVS does not dictate how to use disk space in the checked out
  160.      working directories.  If you write your `Makefile's or scripts in
  161.      every directory so they have to know the relative positions of
  162.      everything else, you wind up requiring the entire repository to be
  163.      checked out.
  164.  
  165.      If you modularize your work, and construct a build system that
  166.      will share files (via links, mounts, `VPATH' in `Makefile's,
  167.      etc.), you can arrange your disk usage however you like.
  168.  
  169.      But you have to remember that *any* such system is a lot of work
  170.      to construct and maintain.  CVS does not address the issues
  171.      involved.
  172.  
  173.      Of course, you should place the tools created to support such a
  174.      build system (scripts, `Makefile's, etc) under CVS.
  175.  
  176.      Figuring out what files need to be rebuilt when something changes
  177.      is, again, something to be handled outside the scope of CVS.  One
  178.      traditional approach is to use `make' for building, and use some
  179.      automated tool for generating the dependencies which `make' uses.
  180.  
  181.      See *Note Builds::, for more information on doing builds in
  182.      conjunction with CVS.
  183.  
  184. CVS is not a substitute for management.
  185.      Your managers and project leaders are expected to talk to you
  186.      frequently enough to make certain you are aware of schedules,
  187.      merge points, branch names and release dates.  If they don't, CVS
  188.      can't help.
  189.  
  190.      CVS is an instrument for making sources dance to your tune.  But
  191.      you are the piper and the composer.  No instrument plays itself or
  192.      writes its own music.
  193.  
  194. CVS is not a substitute for developer communication.
  195.      When faced with conflicts within a single file, most developers
  196.      manage to resolve them without too much effort.  But a more
  197.      general definition of "conflict" includes problems too difficult
  198.      to solve without communication between developers.
  199.  
  200.      CVS cannot determine when simultaneous changes within a single
  201.      file, or across a whole collection of files, will logically
  202.      conflict with one another.  Its concept of a "conflict" is purely
  203.      textual, arising when two changes to the same base file are near
  204.      enough to spook the merge (i.e. `diff3') command.
  205.  
  206.      CVS does not claim to help at all in figuring out non-textual or
  207.      distributed conflicts in program logic.
  208.  
  209.      For example: Say you change the arguments to function `X' defined
  210.      in file `A'.  At the same time, someone edits file `B', adding new
  211.      calls to function `X' using the old arguments.  You are outside
  212.      the realm of CVS's competence.
  213.  
  214.      Acquire the habit of reading specs and talking to your peers.
  215.  
  216. CVS does not have change control
  217.      Change control refers to a number of things.  First of all it can
  218.      mean "bug-tracking", that is being able to keep a database of
  219.      reported bugs and the status of each one (is it fixed?  in what
  220.      release?  has the bug submitter agreed that it is fixed?).  For
  221.      interfacing CVS to an external bug-tracking system, see the
  222.      `rcsinfo' and `verifymsg' files (*note Administrative files::.).
  223.  
  224.      Another aspect of change control is keeping track of the fact that
  225.      changes to several files were in fact changed together as one
  226.      logical change.  If you check in several files in a single `cvs
  227.      commit' operation, CVS then forgets that those files were checked
  228.      in together, and the fact that they have the same log message is
  229.      the only thing tying them together.  Keeping a GNU style
  230.      `ChangeLog' can help somewhat.
  231.  
  232.      Another aspect of change control, in some systems, is the ability
  233.      to keep track of the status of each change.  Some changes have
  234.      been written by a developer, others have been reviewed by a second
  235.      developer, and so on.  Generally, the way to do this with CVS is to
  236.      generate a diff (using `cvs diff' or `diff') and email it to
  237.      someone who can then apply it using the `patch' utility.  This is
  238.      very flexible, but depends on mechanisms outside CVS to make sure
  239.      nothing falls through the cracks.
  240.  
  241. CVS is not an automated testing program
  242.      It should be possible to enforce mandatory use of a testsuite
  243.      using the `commitinfo' file.  I haven't heard a lot about projects
  244.      trying to do that or whether there are subtle gotchas, however.
  245.  
  246. CVS does not have a builtin process model
  247.      Some systems provide ways to ensure that changes or releases go
  248.      through various steps, with various approvals as needed.
  249.      Generally, one can accomplish this with CVS but it might be a
  250.      little more work.  In some cases you'll want to use the
  251.      `commitinfo', `loginfo', `rcsinfo', or `verifymsg' files, to
  252.      require that certain steps be performed before cvs will allow a
  253.      checkin.  Also consider whether features such as branches and tags
  254.      can be used to perform tasks such as doing work in a development
  255.      tree and then merging certain changes over to a stable tree only
  256.      once they have been proven.
  257.  
  258. 
  259. File: cvs.info,  Node: A sample session,  Prev: What is CVS not?,  Up: Overview
  260.  
  261. A sample session
  262. ================
  263.  
  264.    As a way of introducing CVS, we'll go through a typical work-session
  265. using CVS.  The first thing to understand is that CVS stores all files
  266. in a centralized "repository" (*note Repository::.); this section
  267. assumes that a repository is set up.
  268.  
  269.    Suppose you are working on a simple compiler.  The source consists
  270. of a handful of C files and a `Makefile'.  The compiler is called `tc'
  271. (Trivial Compiler), and the repository is set up so that there is a
  272. module called `tc'.
  273.  
  274. * Menu:
  275.  
  276. * Getting the source::          Creating a workspace
  277. * Committing your changes::     Making your work available to others
  278. * Cleaning up::                 Cleaning up
  279. * Viewing differences::         Viewing differences
  280.  
  281. 
  282. File: cvs.info,  Node: Getting the source,  Next: Committing your changes,  Up: A sample session
  283.  
  284. Getting the source
  285. ------------------
  286.  
  287.    The first thing you must do is to get your own working copy of the
  288. source for `tc'.  For this, you use the `checkout' command:
  289.  
  290.      $ cvs checkout tc
  291.  
  292. This will create a new directory called `tc' and populate it with the
  293. source files.
  294.  
  295.      $ cd tc
  296.      $ ls
  297.      CVS         Makefile    backend.c   driver.c    frontend.c  parser.c
  298.  
  299.    The `CVS' directory is used internally by CVS.  Normally, you should
  300. not modify or remove any of the files in it.
  301.  
  302.    You start your favorite editor, hack away at `backend.c', and a
  303. couple of hours later you have added an optimization pass to the
  304. compiler.  A note to RCS and SCCS users: There is no need to lock the
  305. files that you want to edit.  *Note Multiple developers::, for an
  306. explanation.
  307.  
  308. 
  309. File: cvs.info,  Node: Committing your changes,  Next: Cleaning up,  Prev: Getting the source,  Up: A sample session
  310.  
  311. Committing your changes
  312. -----------------------
  313.  
  314.    When you have checked that the compiler is still compilable you
  315. decide to make a new version of `backend.c'.  This will store your new
  316. `backend.c' in the repository and make it available to anyone else who
  317. is using that same repository.
  318.  
  319.      $ cvs commit backend.c
  320.  
  321. CVS starts an editor, to allow you to enter a log message.  You type in
  322. "Added an optimization pass.", save the temporary file, and exit the
  323. editor.
  324.  
  325.    The environment variable `$CVSEDITOR' determines which editor is
  326. started.  If `$CVSEDITOR' is not set, then if the environment variable
  327. `$EDITOR' is set, it will be used. If both `$CVSEDITOR' and `$EDITOR'
  328. are not set then there is a default which will vary with your operating
  329. system, for example `vi' for unix or `notepad' for Windows NT/95.
  330.  
  331.    When CVS starts the editor, it includes a list of files which are
  332. modified.  For the CVS client, this list is based on comparing the
  333. modification time of the file against the modification time that the
  334. file had when it was last gotten or updated.  Therefore, if a file's
  335. modification time has changed but its contents have not, it will show
  336. up as modified.  The simplest way to handle this is simply not to worry
  337. about it--if you proceed with the commit CVS will detect that the
  338. contents are not modified and treat it as an unmodified file.  The next
  339. `update' will clue CVS in to the fact that the file is unmodified, and
  340. it will reset its stored timestamp so that the file will not show up in
  341. future editor sessions.
  342.  
  343.    If you want to avoid starting an editor you can specify the log
  344. message on the command line using the `-m' flag instead, like this:
  345.  
  346.      $ cvs commit -m "Added an optimization pass" backend.c
  347.  
  348. 
  349. File: cvs.info,  Node: Cleaning up,  Next: Viewing differences,  Prev: Committing your changes,  Up: A sample session
  350.  
  351. Cleaning up
  352. -----------
  353.  
  354.    Before you turn to other tasks you decide to remove your working
  355. copy of tc.  One acceptable way to do that is of course
  356.  
  357.      $ cd ..
  358.      $ rm -r tc
  359.  
  360. but a better way is to use the `release' command (*note release::.):
  361.  
  362.      $ cd ..
  363.      $ cvs release -d tc
  364.      M driver.c
  365.      ? tc
  366.      You have [1] altered files in this repository.
  367.      Are you sure you want to release (and delete) module `tc': n
  368.      ** `release' aborted by user choice.
  369.  
  370.    The `release' command checks that all your modifications have been
  371. committed.  If history logging is enabled it also makes a note in the
  372. history file.  *Note history file::.
  373.  
  374.    When you use the `-d' flag with `release', it also removes your
  375. working copy.
  376.  
  377.    In the example above, the `release' command wrote a couple of lines
  378. of output.  `? tc' means that the file `tc' is unknown to CVS.  That is
  379. nothing to worry about: `tc' is the executable compiler, and it should
  380. not be stored in the repository.  *Note cvsignore::, for information
  381. about how to make that warning go away.  *Note release output::, for a
  382. complete explanation of all possible output from `release'.
  383.  
  384.    `M driver.c' is more serious.  It means that the file `driver.c' has
  385. been modified since it was checked out.
  386.  
  387.    The `release' command always finishes by telling you how many
  388. modified files you have in your working copy of the sources, and then
  389. asks you for confirmation before deleting any files or making any note
  390. in the history file.
  391.  
  392.    You decide to play it safe and answer `n <RET>' when `release' asks
  393. for confirmation.
  394.  
  395. 
  396. File: cvs.info,  Node: Viewing differences,  Prev: Cleaning up,  Up: A sample session
  397.  
  398. Viewing differences
  399. -------------------
  400.  
  401.    You do not remember modifying `driver.c', so you want to see what
  402. has happened to that file.
  403.  
  404.      $ cd tc
  405.      $ cvs diff driver.c
  406.  
  407.    This command runs `diff' to compare the version of `driver.c' that
  408. you checked out with your working copy.  When you see the output you
  409. remember that you added a command line option that enabled the
  410. optimization pass.  You check it in, and release the module.
  411.  
  412.      $ cvs commit -m "Added an optimization pass" driver.c
  413.      Checking in driver.c;
  414.      /usr/local/cvsroot/tc/driver.c,v  <--  driver.c
  415.      new revision: 1.2; previous revision: 1.1
  416.      done
  417.      $ cd ..
  418.      $ cvs release -d tc
  419.      ? tc
  420.      You have [0] altered files in this repository.
  421.      Are you sure you want to release (and delete) module `tc': y
  422.  
  423. 
  424. File: cvs.info,  Node: Repository,  Next: Starting a new project,  Prev: Overview,  Up: Top
  425.  
  426. The Repository
  427. **************
  428.  
  429.    The CVS "repository" stores a complete copy of all the files and
  430. directories which are under version control.
  431.  
  432.    Normally, you never access any of the files in the repository
  433. directly.  Instead, you use CVS commands to get your own copy of the
  434. files into a "working directory", and then work on that copy.  When
  435. you've finished a set of changes, you check (or "commit") them back
  436. into the repository.  The repository then contains the changes which
  437. you have made, as well as recording exactly what you changed, when you
  438. changed it, and other such information.  Note that the repository is
  439. not a subdirectory of the working directory, or vice versa; they should
  440. be in separate locations.
  441.  
  442.    CVS can access a repository by a variety of means.  It might be on
  443. the local computer, or it might be on a computer across the room or
  444. across the world.  To distinguish various ways to access a repository,
  445. the repository name can start with an "access method".  For example,
  446. the access method `:local:' means to access a repository directory, so
  447. the repository `:local:/usr/local/cvsroot' means that the repository is
  448. in `/usr/local/cvsroot' on the computer running CVS.  For information
  449. on other access methods, see *Note Remote repositories::.
  450.  
  451.    If the access method is omitted, then if the repository does not
  452. contain `:', then `:local:' is assumed.  If it does contain `:' then
  453. either `:ext:' or `:server:' is assumed.  For example, if you have a
  454. local repository in `/usr/local/cvsroot', you can use
  455. `/usr/local/cvsroot' instead of `:local:/usr/local/cvsroot'.  But if
  456. (under Windows NT, for example) your local repository is
  457. `c:\src\cvsroot', then you must specify the access method, as in
  458. `:local:c:\src\cvsroot'.
  459.  
  460.    The repository is split in two parts.  `$CVSROOT/CVSROOT' contains
  461. administrative files for CVS.  The other directories contain the actual
  462. user-defined modules.
  463.  
  464. * Menu:
  465.  
  466. * Specifying a repository::     Telling CVS where your repository is
  467. * Repository storage::          The structure of the repository
  468. * Working directory storage::   The structure of working directories
  469. * Intro administrative files::  Defining modules
  470. * Multiple repositories::       Multiple repositories
  471. * Creating a repository::       Creating a repository
  472. * Backing up::                  Backing up a repository
  473. * Moving a repository::         Moving a repository
  474. * Remote repositories::         Accessing repositories on remote machines
  475. * Read-only access::            Granting read-only access to the repository
  476. * Server temporary directory::  The server creates temporary directories
  477.  
  478. 
  479. File: cvs.info,  Node: Specifying a repository,  Next: Repository storage,  Up: Repository
  480.  
  481. Telling CVS where your repository is
  482. ====================================
  483.  
  484.    There are several ways to tell CVS where to find the repository.
  485. You can name the repository on the command line explicitly, with the
  486. `-d' (for "directory") option:
  487.  
  488.      cvs -d /usr/local/cvsroot checkout yoyodyne/tc
  489.  
  490.    Or you can set the `$CVSROOT' environment variable to an absolute
  491. path to the root of the repository, `/usr/local/cvsroot' in this
  492. example.  To set `$CVSROOT', `csh' and `tcsh' users should have this
  493. line in their `.cshrc' or `.tcshrc' files:
  494.  
  495.      setenv CVSROOT /usr/local/cvsroot
  496.  
  497. `sh' and `bash' users should instead have these lines in their
  498. `.profile' or `.bashrc':
  499.  
  500.      CVSROOT=/usr/local/cvsroot
  501.      export CVSROOT
  502.  
  503.    A repository specified with `-d' will override the `$CVSROOT'
  504. environment variable.  Once you've checked a working copy out from the
  505. repository, it will remember where its repository is (the information
  506. is recorded in the `CVS/Root' file in the working copy).
  507.  
  508.    The `-d' option and the `CVS/Root' file both override the `$CVSROOT'
  509. environment variable.  If `-d' option differs from `CVS/Root', the
  510. former is used (and specifying `-d' will cause `CVS/Root' to be
  511. updated).  Of course, for proper operation they should be two ways of
  512. referring to the same repository.
  513.  
  514. 
  515. File: cvs.info,  Node: Repository storage,  Next: Working directory storage,  Prev: Specifying a repository,  Up: Repository
  516.  
  517. How data is stored in the repository
  518. ====================================
  519.  
  520.    For most purposes it isn't important *how* CVS stores information in
  521. the repository.  In fact, the format has changed in the past, and is
  522. likely to change in the future.  Since in almost all cases one accesses
  523. the repository via CVS commands, such changes need not be disruptive.
  524.  
  525.    However, in some cases it may be necessary to understand how CVS
  526. stores data in the repository, for example you might need to track down
  527. CVS locks (*note Concurrency::.) or you might need to deal with the
  528. file permissions appropriate for the repository.
  529.  
  530. * Menu:
  531.  
  532. * Repository files::            What files are stored in the repository
  533. * File permissions::            File permissions
  534. * Windows permissions::         Issues specific to Windows
  535. * Attic::                       Some files are stored in the Attic
  536. * CVS in repository::           Additional information in CVS directory
  537. * Locks::                       CVS locks control concurrent accesses
  538. * CVSROOT storage::             A few things about CVSROOT are different
  539.  
  540. 
  541. File: cvs.info,  Node: Repository files,  Next: File permissions,  Up: Repository storage
  542.  
  543. Where files are stored within the repository
  544. --------------------------------------------
  545.  
  546.    The overall structure of the repository is a directory tree
  547. corresponding to the directories in the working directory.  For
  548. example, supposing the repository is in
  549.  
  550.      /usr/local/cvsroot
  551.  
  552. here is a possible directory tree (showing only the directories):
  553.  
  554.      /usr
  555.       |
  556.       +--local
  557.       |   |
  558.       |   +--cvsroot
  559.       |   |    |
  560.       |   |    +--CVSROOT
  561.                |      (administrative files)
  562.                |
  563.                +--gnu
  564.                |   |
  565.                |   +--diff
  566.                |   |   (source code to GNU diff)
  567.                |   |
  568.                |   +--rcs
  569.                |   |   (source code to RCS)
  570.                |   |
  571.                |   +--cvs
  572.                |       (source code to CVS)
  573.                |
  574.                +--yoyodyne
  575.                    |
  576.                    +--tc
  577.                    |    |
  578.                    |    +--man
  579.                    |    |
  580.                    |    +--testing
  581.                    |
  582.                    +--(other Yoyodyne software)
  583.  
  584.    With the directories are "history files" for each file under version
  585. control.  The name of the history file is the name of the corresponding
  586. file with `,v' appended to the end.  Here is what the repository for
  587. the `yoyodyne/tc' directory might look like:
  588.        `$CVSROOT'
  589.          |
  590.          +--yoyodyne
  591.          |   |
  592.          |   +--tc
  593.          |   |   |
  594.                  +--Makefile,v
  595.                  +--backend.c,v
  596.                  +--driver.c,v
  597.                  +--frontend.c,v
  598.                  +--parser.c,v
  599.                  +--man
  600.                  |    |
  601.                  |    +--tc.1,v
  602.                  |
  603.                  +--testing
  604.                       |
  605.                       +--testpgm.t,v
  606.                       +--test2.t,v
  607.  
  608.    The history files contain, among other things, enough information to
  609. recreate any revision of the file, a log of all commit messages and the
  610. user-name of the person who committed the revision.  The history files
  611. are known as "RCS files", because the first program to store files in
  612. that format was a version control system known as RCS.  For a full
  613. description of the file format, see the `man' page `rcsfile(5)',
  614. distributed with RCS, or the file `doc/RCSFILES' in the CVS source
  615. distribution.  This file format has become very common--many systems
  616. other than CVS or RCS can at least import history files in this format.
  617.  
  618.    The RCS files used in CVS differ in a few ways from the standard
  619. format.  The biggest difference is magic branches; for more information
  620. see *Note Magic branch numbers::.  Also in CVS the valid tag names are
  621. a subset of what RCS accepts; for CVS's rules see *Note Tags::.
  622.  
  623. 
  624. File: cvs.info,  Node: File permissions,  Next: Windows permissions,  Prev: Repository files,  Up: Repository storage
  625.  
  626. File permissions
  627. ----------------
  628.  
  629.    All `,v' files are created read-only, and you should not change the
  630. permission of those files.  The directories inside the repository
  631. should be writable by the persons that have permission to modify the
  632. files in each directory.  This normally means that you must create a
  633. UNIX group (see group(5)) consisting of the persons that are to edit
  634. the files in a project, and set up the repository so that it is that
  635. group that owns the directory.
  636.  
  637.    This means that you can only control access to files on a
  638. per-directory basis.
  639.  
  640.    Note that users must also have write access to check out files,
  641. because CVS needs to create lock files (*note Concurrency::.).
  642.  
  643.    Also note that users must have write access to the
  644. `CVSROOT/val-tags' file.  CVS uses it to keep track of what tags are
  645. valid tag names (it is sometimes updated when tags are used, as well as
  646. when they are created).
  647.  
  648.    Each RCS file will be owned by the user who last checked it in.
  649. This has little significance; what really matters is who owns the
  650. directories.
  651.  
  652.    CVS tries to set up reasonable file permissions for new directories
  653. that are added inside the tree, but you must fix the permissions
  654. manually when a new directory should have different permissions than its
  655. parent directory.  If you set the `CVSUMASK' environment variable that
  656. will control the file permissions which CVS uses in creating directories
  657. and/or files in the repository.  `CVSUMASK' does not affect the file
  658. permissions in the working directory; such files have the permissions
  659. which are typical for newly created files, except that sometimes CVS
  660. creates them read-only (see the sections on watches, *Note Setting a
  661. watch::; -r, *Note Global options::; or CVSREAD, *Note Environment
  662. variables::).
  663.  
  664.    Note that using the client/server CVS (*note Remote
  665. repositories::.), there is no good way to set `CVSUMASK'; the setting
  666. on the client machine has no effect.  If you are connecting with `rsh',
  667. you can set `CVSUMASK' in `.bashrc' or `.cshrc', as described in the
  668. documentation for your operating system.  This behavior might change in
  669. future versions of CVS; do not rely on the setting of `CVSUMASK' on the
  670. client having no effect.
  671.  
  672.    Using pserver, you will generally need stricter permissions on the
  673. CVSROOT directory and directories above it in the tree; see *Note
  674. Password authentication security::.
  675.  
  676.    Some operating systems have features which allow a particular
  677. program to run with the ability to perform operations which the caller
  678. of the program could not.  For example, the set user ID (setuid) or set
  679. group ID (setgid) features of unix or the installed image feature of
  680. VMS.  CVS was not written to use such features and therefore attempting
  681. to install CVS in this fashion will provide protection against only
  682. accidental lapses; anyone who is trying to circumvent the measure will
  683. be able to do so, and depending on how you have set it up may gain
  684. access to more than just CVS.  You may wish to instead consider
  685. pserver.  It shares some of the same attributes, in terms of possibly
  686. providing a false sense of security or opening security holes wider
  687. than the ones you are trying to fix, so read the documentation on
  688. pserver security carefully if you are considering this option (*Note
  689. Password authentication security::).
  690.  
  691. 
  692. File: cvs.info,  Node: Windows permissions,  Next: Attic,  Prev: File permissions,  Up: Repository storage
  693.  
  694. File Permission issues specific to Windows
  695. ------------------------------------------
  696.  
  697.    Some file permission issues are specific to Windows operating
  698. systems (Windows 95, Windows NT, and presumably future operating
  699. systems in this family.  Some of the following might apply to OS/2 but
  700. I'm not sure).
  701.  
  702.    If you are using local CVS and the repository is on a networked file
  703. system which is served by the Samba SMB server, some people have
  704. reported problems with permissions.  Enabling WRITE=YES in the samba
  705. configuration is said to fix/workaround it.  Disclaimer: I haven't
  706. investigated enough to know the implications of enabling that option,
  707. nor do I know whether there is something which CVS could be doing
  708. differently in order to avoid the problem.  If you find something out,
  709. please let us know as described in *Note BUGS::.
  710.  
  711. 
  712. File: cvs.info,  Node: Attic,  Next: CVS in repository,  Prev: Windows permissions,  Up: Repository storage
  713.  
  714. The attic
  715. ---------
  716.  
  717.    You will notice that sometimes CVS stores an RCS file in the
  718. `Attic'.  For example, if the CVSROOT is `/usr/local/cvsroot' and we are
  719. talking about the file `backend.c' in the directory `yoyodyne/tc', then
  720. the file normally would be in
  721.  
  722.      /usr/local/cvsroot/yoyodyne/tc/backend.c,v
  723.  
  724.    but if it goes in the attic, it would be in
  725.  
  726.      /usr/local/cvsroot/yoyodyne/tc/Attic/backend.c,v
  727.  
  728.    instead.  It should not matter from a user point of view whether a
  729. file is in the attic; CVS keeps track of this and looks in the attic
  730. when it needs to.  But in case you want to know, the rule is that the
  731. RCS file is stored in the attic if and only if the head revision on the
  732. trunk has state `dead'.  A `dead' state means that file has been
  733. removed, or never added, for that revision.  For example, if you add a
  734. file on a branch, it will have a trunk revision in `dead' state, and a
  735. branch revision in a non-`dead' state.
  736.  
  737. 
  738. File: cvs.info,  Node: CVS in repository,  Next: Locks,  Prev: Attic,  Up: Repository storage
  739.  
  740. The CVS directory in the repository
  741. -----------------------------------
  742.  
  743.    The `CVS' directory in each repository directory contains
  744. information such as file attributes (in a file called `CVS/fileattr';
  745. see fileattr.h in the CVS source distribution for more documentation).
  746. In the future additional files may be added to this directory, so
  747. implementations should silently ignore additional files.
  748.  
  749.    This behavior is implemented only by CVS 1.7 and later; for details
  750. see *Note Watches Compatibility::.
  751.  
  752. 
  753. File: cvs.info,  Node: Locks,  Next: CVSROOT storage,  Prev: CVS in repository,  Up: Repository storage
  754.  
  755. CVS locks in the repository
  756. ---------------------------
  757.  
  758.    For an introduction to CVS locks focusing on user-visible behavior,
  759. see *Note Concurrency::.  The following section is aimed at people who
  760. are writing tools which want to access a CVS repository without
  761. interfering with other tools acessing the same repository.  If you find
  762. yourself confused by concepts described here, like "read lock", "write
  763. lock", and "deadlock", you might consult the literature on operating
  764. systems or databases.
  765.  
  766.    Any file in the repository with a name starting with `#cvs.rfl' is a
  767. read lock.  Any file in the repository with a name starting with
  768. `#cvs.wfl' is a write lock.  Old versions of CVS (before CVS 1.5) also
  769. created files with names starting with `#cvs.tfl', but they are not
  770. discussed here.  The directory `#cvs.lock' serves as a master lock.
  771. That is, one must obtain this lock first before creating any of the
  772. other locks.
  773.  
  774.    To obtain a readlock, first create the `#cvs.lock' directory.  This
  775. operation must be atomic (which should be true for creating a directory
  776. under most operating systems).  If it fails because the directory
  777. already existed, wait for a while and try again.  After obtaining the
  778. `#cvs.lock' lock, create a file whose name is `#cvs.rfl' followed by
  779. information of your choice (for example, hostname and process
  780. identification number).  Then remove the `#cvs.lock' directory to
  781. release the master lock.  Then proceed with reading the repository.
  782. When you are done, remove the `#cvs.rfl' file to release the read lock.
  783.  
  784.    To obtain a writelock, first create the `#cvs.lock' directory, as
  785. with a readlock.  Then check that there are no files whose names start
  786. with `#cvs.rfl'.  If there are, remove `#cvs.lock', wait for a while,
  787. and try again.  If there are no readers, then create a file whose name
  788. is `#cvs.wfl' followed by information of your choice (for example,
  789. hostname and process identification number).  Hang on to the
  790. `#cvs.lock' lock.  Proceed with writing the repository.  When you are
  791. done, first remove the `#cvs.wfl' file and then the `#cvs.lock'
  792. directory. Note that unlike the `#cvs.rfl' file, the `#cvs.wfl' file is
  793. just informational; it has no effect on the locking operation beyond
  794. what is provided by holding on to the `#cvs.lock' lock itself.
  795.  
  796.    Note that each lock (writelock or readlock) only locks a single
  797. directory in the repository, including `Attic' and `CVS' but not
  798. including subdirectories which represent other directories under
  799. version control.  To lock an entire tree, you need to lock each
  800. directory (note that if you fail to obtain any lock you need, you must
  801. release the whole tree before waiting and trying again, to avoid
  802. deadlocks).
  803.  
  804.    Note also that CVS expects writelocks to control access to
  805. individual `foo,v' files.  RCS has a scheme where the `,foo,' file
  806. serves as a lock, but CVS does not implement it and so taking out a CVS
  807. writelock is recommended.  See the comments at rcs_internal_lockfile in
  808. the CVS source code for further discussion/rationale.
  809.  
  810. 
  811. File: cvs.info,  Node: CVSROOT storage,  Prev: Locks,  Up: Repository storage
  812.  
  813. How files are stored in the CVSROOT directory
  814. ---------------------------------------------
  815.  
  816.    The `$CVSROOT/CVSROOT' directory contains the various administrative
  817. files.  In some ways this directory is just like any other directory in
  818. the repository; it contains RCS files whose names end in `,v', and many
  819. of the CVS commands operate on it the same way.  However, there are a
  820. few differences.
  821.  
  822.    For each administrative file, in addition to the RCS file, there is
  823. also a checked out copy of the file.  For example, there is an RCS file
  824. `loginfo,v' and a file `loginfo' which contains the latest revision
  825. contained in `loginfo,v'.  When you check in an administrative file,
  826. CVS should print
  827.  
  828.      cvs commit: Rebuilding administrative file database
  829.  
  830. and update the checked out copy in `$CVSROOT/CVSROOT'.  If it does not,
  831. there is something wrong (*note BUGS::.).  To add your own files to the
  832. files to be updated in this fashion, you can add them to the
  833. `checkoutlist' administrative file.
  834.  
  835.    By default, the `modules' file behaves as described above.  If the
  836. modules file is very large, storing it as a flat text file may make
  837. looking up modules slow (I'm not sure whether this is as much of a
  838. concern now as when CVS first evolved this feature; I haven't seen
  839. benchmarks).  Therefore, by making appropriate edits to the CVS source
  840. code one can store the modules file in a database which implements the
  841. `ndbm' interface, such as Berkeley db or GDBM.  If this option is in
  842. use, then the modules database will be stored in the files `modules.db',
  843. `modules.pag', and/or `modules.dir'.
  844.  
  845.    For information on the meaning of the various administrative files,
  846. see *Note Administrative files::.
  847.  
  848. 
  849. File: cvs.info,  Node: Working directory storage,  Next: Intro administrative files,  Prev: Repository storage,  Up: Repository
  850.  
  851. How data is stored in the working directory
  852. ===========================================
  853.  
  854.    While we are discussing CVS internals which may become visible from
  855. time to time, we might as well talk about what CVS puts in the `CVS'
  856. directories in the working directories.  As with the repository, CVS
  857. handles this information and one can usually access it via CVS
  858. commands.  But in some cases it may be useful to look at it, and other
  859. programs, such as the `jCVS' graphical user interface or the `VC'
  860. package for emacs, may need to look at it.  Such programs should follow
  861. the recommendations in this section if they hope to be able to work
  862. with other programs which use those files, including future versions of
  863. the programs just mentioned and the command-line CVS client.
  864.  
  865.    The `CVS' directory contains several files.  Programs which are
  866. reading this directory should silently ignore files which are in the
  867. directory but which are not documented here, to allow for future
  868. expansion.
  869.  
  870. `Root'
  871.      This file contains the current CVS root, as described in *Note
  872.      Specifying a repository::.
  873.  
  874. `Repository'
  875.      This file contains the directory within the repository which the
  876.      current directory corresponds with.  It can be either an absolute
  877.      pathname or a relative pathname; CVS has had the ability to read
  878.      either format since at least version 1.3 or so.  The relative
  879.      pathname is relative to the root, and is the more sensible
  880.      approach, but the absolute pathname is quite common and
  881.      implementations should accept either.  For example, after the
  882.      command
  883.  
  884.           cvs -d :local:/usr/local/cvsroot checkout yoyodyne/tc
  885.  
  886.      `Root' will contain
  887.  
  888.           :local:/usr/local/cvsroot
  889.  
  890.      and `Repository' will contain either
  891.  
  892.           /usr/local/cvsroot/yoyodyne/tc
  893.  
  894.      or
  895.  
  896.           yoyodyne/tc
  897.  
  898. `Entries'
  899.      This file lists the files and directories in the working
  900.      directory.  It is a text file according to the conventions
  901.      appropriate for the operating system in question.  The first
  902.      character of each line indicates what sort of line it is.  If the
  903.      character is unrecognized, programs reading the file should
  904.      silently skip that line, to allow for future expansion.
  905.  
  906.      If the first character is `/', then the format is:
  907.  
  908.           /NAME/REVISION/TIMESTAMP[+CONFLICT]/OPTIONS/TAGDATE
  909.  
  910.      where `[' and `]' are not part of the entry, but instead indicate
  911.      that the `+' and conflict marker are optional.  NAME is the name
  912.      of the file within the directory.  REVISION is the revision that
  913.      the file in the working derives from, or `0' for an added file, or
  914.      `-' followed by a revision for a removed file.  TIMESTAMP is the
  915.      timestamp of the file at the time that CVS created it; if the
  916.      timestamp differs with the actual modification time of the file it
  917.      means the file has been modified.  It is in Universal Time (UT),
  918.      stored in the format used by the ISO C asctime() function (for
  919.      example, `Sun Apr  7 01:29:26 1996').  One may write a string
  920.      which is not in that format, for example, `Result of merge', to
  921.      indicate that the file should always be considered to be modified.
  922.      This is not a special case; to see whether a file is modified a
  923.      program should take the timestamp of the file and simply do a
  924.      string compare with TIMESTAMP.  CONFLICT indicates that there was
  925.      a conflict; if it is the same as the actual modification time of
  926.      the file it means that the user has obviously not resolved the
  927.      conflict.  OPTIONS contains sticky options (for example `-kb' for a
  928.      binary file).  TAGDATE contains `T' followed by a tag name, or `D'
  929.      for a date, followed by a sticky tag or date.  Note that if
  930.      TIMESTAMP contains a pair of timestamps separated by a space,
  931.      rather than a single timestamp, you are dealing with a version of
  932.      CVS earlier than CVS 1.5 (not documented here).
  933.  
  934.      If the first character of a line in `Entries' is `D', then it
  935.      indicates a subdirectory.  `D' on a line all by itself indicates
  936.      that the program which wrote the `Entries' file does record
  937.      subdirectories (therefore, if there is such a line and no other
  938.      lines beginning with `D', one knows there are no subdirectories).
  939.      Otherwise, the line looks like:
  940.  
  941.           D/NAME/FILLER1/FILLER2/FILLER3/FILLER4
  942.  
  943.      where NAME is the name of the subdirectory, and all the FILLER
  944.      fields should be silently ignored, for future expansion.  Programs
  945.      which modify `Entries' files should preserve these fields.
  946.  
  947. `Entries.Log'
  948.      This file does not record any information beyond that in
  949.      `Entries', but it does provide a way to update the information
  950.      without having to rewrite the entire `Entries' file, including the
  951.      ability to preserve the information even if the program writing
  952.      `Entries' and `Entries.Log' abruptly aborts.  Programs which are
  953.      reading the `Entries' file should also check for `Entries.Log'.
  954.      If the latter exists, they should read `Entries' and then apply
  955.      the changes mentioned in `Entries.Log'.  After applying the
  956.      changes, the recommended practice is to rewrite `Entries' and then
  957.      delete `Entries.Log'.  The format of a line in `Entries.Log' is a
  958.      single character command followed by a space followed by a line in
  959.      the format specified for a line in `Entries'.  The single
  960.      character command is `A' to indicate that the entry is being added,
  961.      `R' to indicate that the entry is being removed, or any other
  962.      character to indicate that the entire line in `Entries.Log' should
  963.      be silently ignored (for future expansion).  If the second
  964.      character of the line in `Entries.Log' is not a space, then it was
  965.      written by an older version of CVS (not documented here).
  966.  
  967. `Entries.Backup'
  968.      This is a temporary file.  Recommended usage is to write a new
  969.      entries file to `Entries.Backup', and then to rename it
  970.      (atomically, where possible) to `Entries'.
  971.  
  972. `Entries.Static'
  973.      The only relevant thing about this file is whether it exists or
  974.      not.  If it exists, then it means that only part of a directory
  975.      was gotten and CVS will not create additional files in that
  976.      directory.  To clear it, use the `update' command with the `-d'
  977.      option, which will get the additional files and remove
  978.      `Entries.Static'.
  979.  
  980. `Tag'
  981.      This file contains per-directory sticky tags or dates.  The first
  982.      character is `T' for a branch tag, `N' for a non-branch tag, or
  983.      `D' for a date, or another character to mean the file should be
  984.      silently ignored, for future expansion.  This character is
  985.      followed by the tag or date.  Note that per-directory sticky tags
  986.      or dates are used for things like applying to files which are
  987.      newly added; they might not be the same as the sticky tags or
  988.      dates on individual files.  For general information on sticky tags
  989.      and dates, see *Note Sticky tags::.
  990.  
  991. `Checkin.prog'
  992. `Update.prog'
  993.      These files store the programs specified by the `-i' and `-u'
  994.      options in the modules file, respectively.
  995.  
  996. `Notify'
  997.      This file stores notifications (for example, for `edit' or
  998.      `unedit') which have not yet been sent to the server.  Its format
  999.      is not yet documented here.
  1000.  
  1001. `Notify.tmp'
  1002.      This file is to `Notify' as `Entries.Backup' is to `Entries'.
  1003.      That is, to write `Notify', first write the new contents to
  1004.      `Notify.tmp' and then (atomically where possible), rename it to
  1005.      `Notify'.
  1006.  
  1007. `Base'
  1008.      If watches are in use, then an `edit' command stores the original
  1009.      copy of the file in the `Base' directory.  This allows the
  1010.      `unedit' command to operate even if it is unable to communicate
  1011.      with the server.
  1012.  
  1013. `Baserev'
  1014.      The file lists the revision for each of the files in the `Base'
  1015.      directory.  The format is:
  1016.  
  1017.           BNAME/REV/EXPANSION
  1018.  
  1019.      where EXPANSION should be ignored, to allow for future expansion.
  1020.  
  1021. `Baserev.tmp'
  1022.      This file is to `Baserev' as `Entries.Backup' is to `Entries'.
  1023.      That is, to write `Baserev', first write the new contents to
  1024.      `Baserev.tmp' and then (atomically where possible), rename it to
  1025.      `Baserev'.
  1026.  
  1027. `Template'
  1028.      This file contains the template specified by the `rcsinfo' file
  1029.      (*note rcsinfo::.).  It is only used by the client; the
  1030.      non-client/server CVS consults `rcsinfo' directly.
  1031.  
  1032. 
  1033. File: cvs.info,  Node: Intro administrative files,  Next: Multiple repositories,  Prev: Working directory storage,  Up: Repository
  1034.  
  1035. The administrative files
  1036. ========================
  1037.  
  1038.    The directory `$CVSROOT/CVSROOT' contains some "administrative
  1039. files".  *Note Administrative files::, for a complete description.  You
  1040. can use CVS without any of these files, but some commands work better
  1041. when at least the `modules' file is properly set up.
  1042.  
  1043.    The most important of these files is the `modules' file.  It defines
  1044. all modules in the repository.  This is a sample `modules' file.
  1045.  
  1046.      CVSROOT         CVSROOT
  1047.      modules         CVSROOT modules
  1048.      cvs             gnu/cvs
  1049.      rcs             gnu/rcs
  1050.      diff            gnu/diff
  1051.      tc              yoyodyne/tc
  1052.  
  1053.    The `modules' file is line oriented.  In its simplest form each line
  1054. contains the name of the module, whitespace, and the directory where
  1055. the module resides.  The directory is a path relative to `$CVSROOT'.
  1056. The last four lines in the example above are examples of such lines.
  1057.  
  1058.    The line that defines the module called `modules' uses features that
  1059. are not explained here.  *Note modules::, for a full explanation of all
  1060. the available features.
  1061.  
  1062. Editing administrative files
  1063. ----------------------------
  1064.  
  1065.    You edit the administrative files in the same way that you would edit
  1066. any other module.  Use `cvs checkout CVSROOT' to get a working copy,
  1067. edit it, and commit your changes in the normal way.
  1068.  
  1069.    It is possible to commit an erroneous administrative file.  You can
  1070. often fix the error and check in a new revision, but sometimes a
  1071. particularly bad error in the administrative file makes it impossible
  1072. to commit new revisions.
  1073.  
  1074. 
  1075. File: cvs.info,  Node: Multiple repositories,  Next: Creating a repository,  Prev: Intro administrative files,  Up: Repository
  1076.  
  1077. Multiple repositories
  1078. =====================
  1079.  
  1080.    In some situations it is a good idea to have more than one
  1081. repository, for instance if you have two development groups that work
  1082. on separate projects without sharing any code.  All you have to do to
  1083. have several repositories is to specify the appropriate repository,
  1084. using the `CVSROOT' environment variable, the `-d' option to CVS, or
  1085. (once you have checked out a working directory) by simply allowing CVS
  1086. to use the repository that was used to check out the working directory
  1087. (*note Specifying a repository::.).
  1088.  
  1089.    The big advantage of having multiple repositories is that they can
  1090. reside on different servers.  The big disadvantage is that you cannot
  1091. have a single CVS command recurse into directories which comes from
  1092. different repositories.  Generally speaking, if you are thinking of
  1093. setting up several repositories on the same machine, you might want to
  1094. consider using several directories within the same repository.
  1095.  
  1096.    None of the examples in this manual show multiple repositories.
  1097.  
  1098. 
  1099. File: cvs.info,  Node: Creating a repository,  Next: Backing up,  Prev: Multiple repositories,  Up: Repository
  1100.  
  1101. Creating a repository
  1102. =====================
  1103.  
  1104.    To set up a CVS repository, first choose the machine and disk on
  1105. which you want to store the revision history of the source files.  CPU
  1106. and memory requirements are modest, so most machines should be
  1107. adequate.  For details see *Note Server requirements::.
  1108.  
  1109.    To estimate disk space requirements, if you are importing RCS files
  1110. from another system, the size of those files is the approximate initial
  1111. size of your repository, or if you are starting without any version
  1112. history, a rule of thumb is to allow for the server approximately three
  1113. times the size of the code to be under CVS for the repository (you will
  1114. eventually outgrow this, but not for a while).  On the machines on
  1115. which the developers will be working, you'll want disk space for
  1116. approximately one working directory for each developer (either the
  1117. entire tree or a portion of it, depending on what each developer uses).
  1118.  
  1119.    The repository should be accessable (directly or via a networked
  1120. file system) from all machines which want to use CVS in server or local
  1121. mode; the client machines need not have any access to it other than via
  1122. the CVS protocol.  It is not possible to use CVS to read from a
  1123. repository which one only has read access to; CVS needs to be able to
  1124. create lock files (*note Concurrency::.).
  1125.  
  1126.    To create a repository, run the `cvs init' command.  It will set up
  1127. an empty repository in the CVS root specified in the usual way (*note
  1128. Repository::.).  For example,
  1129.  
  1130.      cvs -d /usr/local/cvsroot init
  1131.  
  1132.    `cvs init' is careful to never overwrite any existing files in the
  1133. repository, so no harm is done if you run `cvs init' on an already
  1134. set-up repository.
  1135.  
  1136.    `cvs init' will enable history logging; if you don't want that,
  1137. remove the history file after running `cvs init'.  *Note history file::.
  1138.  
  1139.